home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / telecomm / misc / xprkermit.2.lha / ckxmai.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-07  |  40.8 KB  |  1,354 lines
  1. char *versio = "C-Kermit 5A(189)-XPR, 14 Feb 94"; /* Version herald. */
  2. long vernum =            501189L;
  3. /*
  4.   String and numeric version numbers, keep these two in sync!
  5.   First digit of vermum = major version, i.e. 5.
  6.   Second 2 digits of vernum: 00 = no minor version, 01 = A, 02 = B, etc.
  7.   Last three digits are edit number. 
  8.   For Macintosh, also remember to change the Mac-specific version in ckmkr2.r.
  9. */
  10.  
  11. #ifndef VERWHO
  12. /* Change verwho in following line, or with -DVERWHO=x in makefile CFLAGS. */
  13. #define VERWHO 91330
  14. #endif /* VERWHO */
  15. int verwho = VERWHO; /* Who produced this version, 0 = Columbia University */
  16. /*
  17.   IMPORTANT: If you are working on your own private version of C-Kermit, please
  18.   include some special notation, like your site name or your initials, in the
  19.   "versio" string, e.g. "5A(182)-XXX", and use a nonzero code for the "verwho"
  20.   variable (e.g. in the USA use your zip code).  Unless we stick to this
  21.   discipline, divergent copies of C-Kermit will begin to appear that are
  22.   intistinguishable from each other, which is a big support issue.  Also, if
  23.   you have edited C-Kermit and made copies available to others, please add
  24.   appropriate text to the BUG command (ckuus6.c, function dobug()).
  25. */
  26. #define CKXMAI
  27.  
  28. /*  C K X M A I  --  Amiga XPR C-Kermit "Main" program  */
  29.  
  30. /*
  31.   Author: Stephen R. Walton (swalton@huey.csun.edu)
  32.   California State University, Northridgen
  33.   First released March 1993.
  34.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  35.   York.  Permission is granted to any individual or institution to use this
  36.   software as long as it is not sold for profit.  This copyright notice must be
  37.   retained.  This software may not be included in commercial products without
  38.   written permission of Columbia University.
  39. */
  40. /*
  41.   The Kermit file transfer protocol was developed at the Columbia University
  42.   Center for Computing Activities (CUCCA).  It is named after Kermit the Frog,
  43.   star of the television series THE MUPPET SHOW; the name is used by permission
  44.   of Henson Associates, Inc.  "Kermit" is also Celtic for "free".
  45. */
  46. /*
  47.   DISCLAIMER:
  48.  
  49.   The C-Kermit software is provided in source code form by Kermit Development
  50.   and Distribution, Columbia University.  The software is provided "as is;" no
  51.   other warranty is provided, express or implied, including without
  52.   limitations, any implied warranty of merchantability or implied warranty of
  53.   fitness for a particular purpose.
  54.  
  55.   Neither Columbia University nor any of the contributors to the C-Kermit
  56.   development effort, including, but not limited to, AT&T, Digital Equipment
  57.   Corporation, Data General Corporation, or International Business Machines
  58.   Corporation, warrant C-Kermit software or documentation in any way.  In
  59.   addition, neither the authors of any Kermit programs, publications or
  60.   documentation, nor Columbia University nor any contributing institutions or
  61.   individuals acknowledge any liability resulting from program or
  62.   documentation errors.
  63. */
  64.  
  65. /*
  66.   ckcsym.h is used for for defining symbols that normally would be defined
  67.   using -D or -d on the cc command line, for use with compilers that don't
  68.   support this feature.
  69. */
  70. #include "ckcsym.h"
  71. #include "ckcasc.h"            /* ASCII character symbols */
  72. #include "ckcdeb.h"            /* Debug & other symbols */
  73. #include "ckcker.h"            /* Kermit symbols */
  74. #include "ckcnet.h"            /* Network symbols */
  75.  
  76. char *srvtxt = "Now in server mode.  But shouldn't be\r\n";
  77.  
  78. /* Declarations for Send-Init Parameters */
  79.  
  80. int spsiz = DSPSIZ,                     /* Current packet size to send */
  81.     spmax = DSPSIZ,            /* Biggest packet size we can send */
  82.     spsizr = DSPSIZ,            /* Send-packet size requested */
  83.     spsizf = 0,                         /* Flag to override size negotiation */
  84.     rpsiz = DRPSIZ,                     /* Biggest we want to receive */
  85.     urpsiz = DRPSIZ,            /* User-requested receive pkt size */
  86.     maxrps = MAXRP,            /* Maximum incoming long packet size */
  87.     maxsps = MAXSP,            /* Maximum outbound l.p. size */
  88.     maxtry = MAXTRY,            /* Maximum retries per packet */
  89.     wslots = 1,                /* Window size currently in use */
  90.     wslotr = 1,                /* Window size from SET WINDOW */
  91.     wslotn = 1,                /* Window size negotiated in S-pkt */
  92.     timeouts = 0,            /* For statistics reporting */
  93.     spackets = 0,            /*  ... */
  94.     rpackets = 0,            /*  ... */
  95.     retrans = 0,            /*  ... */
  96.     crunched = 0,            /*  ... */
  97.     wmax = 0,                /*  ... */
  98.     wcur = 0,                /*  ... */
  99.     srvdis = 0,                /* Server file xfer display */
  100.     srvtim = DSRVTIM,            /* Server command wait timeout */
  101. /*
  102.   timint is the timeout interval I use when waiting for a packet.
  103.   pkttim is the SET RECEIVE TIMEOUT value, sent to the other Kermit.
  104.   rtimo is the SET SEND TIMEOUT value.  rtimo is the initial value of
  105.   timint.  timint is changed by the value in the incoming negotiation
  106.   packet unless a SET SEND TIMEOUT command was given.
  107. */
  108.     timint = DMYTIM,                    /* Timeout interval I use */
  109.     pkttim = URTIME,            /* Timeout I want you to use */
  110.     rtimo = DMYTIM,            /* Normal packet wait timeout */
  111.     timef = 0,                          /* Flag to override what you ask */
  112.     npad = MYPADN,                      /* How much padding to send */
  113.     mypadn = MYPADN,                    /* How much padding to ask for */
  114.     bctr = 1,                           /* Block check type requested */
  115.     bctu = 1,                           /* Block check type used */
  116.     bctl = 1,                /* Block check length */
  117.     ebq =  MYEBQ,                       /* 8th bit prefix */
  118.     ebqflg = 0,                         /* 8th-bit quoting flag */
  119.     rqf = -1,                /* Flag used in 8bq negotiation */
  120.     rq = 0,                /* Received 8bq bid */
  121.     sq = 'Y',                /* Sent 8bq bid */
  122.     rpt = 0,                            /* Repeat count */
  123.     rptq = MYRPTQ,                      /* Repeat prefix */
  124.     rptflg = 0,                         /* Repeat processing flag */
  125.     rptena = 1,                /* Repeat processing enabled */
  126.     xfrcan = 1,                /* Transfer cancellation enabled */
  127.     xfrchr = 3,                /* Transfer cancel char = Ctrl-C */
  128.     xfrnum = 2;                /* Need two of them. */
  129.  
  130. int capas = 9,                /* Position of Capabilities */
  131.     atcapb = 8,                /* Attribute capability */
  132.     atcapr = 1,                /*  requested */
  133.     atcapu = 0,                /*  used */
  134.     swcapb = 4,                /* Sliding Window capability */
  135.     swcapr = 1,                /*  requested (allowed) */
  136.     swcapu = 0,                /*  used */
  137.     lpcapb = 2,                /* Long Packet capability */
  138.     lpcapr = 1,                /*  requested */
  139.     lpcapu = 0,                /*  used */
  140.     lscapb = 32,            /* Locking Shift capability */
  141.     lscapr = 1,                /*  requested by default */
  142.     lscapu = 0;                /*  used */
  143.  
  144. /* Flags for whether to use particular attributes */
  145.  
  146. int atenci = 1,                /* Encoding in */
  147.     atenco = 1,                /* Encoding out */
  148.     atdati = 1,                /* Date in */
  149.     atdato = 1,                /* Date out */
  150.     atdisi = 1,                /* Disposition in/out */
  151.     atdiso = 1,
  152.     atleni = 1,                /* Length in/out (both kinds) */
  153.     atleno = 1,
  154.     atblki = 1,                /* Blocksize in/out */
  155.     atblko = 1,
  156.     attypi = 1,                /* File type in/out */
  157.     attypo = 1,
  158.     atsidi = 1,                /* System ID in/out */
  159.     atsido = 1,
  160.     atsysi = 1,                   /* System-dependent parameters in/out */
  161.     atsyso = 1;
  162.  
  163. CHAR padch = MYPADC,                    /* Padding character to send */
  164.     mypadc = MYPADC,                    /* Padding character to ask for */
  165.     seol = MYEOL,                       /* End-Of-Line character to send */
  166.     eol = MYEOL,                        /* End-Of-Line character to look for */
  167.     ctlq = CTLQ,                        /* Control prefix in incoming data */
  168.     myctlq = CTLQ,                      /* Outbound control character prefix */
  169.     myrptq = MYRPTQ;            /* Repeat prefix I want to use */
  170.  
  171. struct zattr iattr;            /* Incoming file attributes */
  172.  
  173. /* File related variables, mainly for the benefit of VAX/VMS */
  174.  
  175. int fblksiz = DBLKSIZ;        /* File blocksize */
  176. int frecl = DLRECL;        /* File record length */
  177. int frecfm = XYFF_S;        /* File record format (default = stream) */
  178. int forg = XYFO_S;        /* File organization (sequential) */
  179. int fcctrl = XYFP_N;        /* File carriage control (ctrl chars) */
  180.  
  181. int lf_opts = 0;
  182.  
  183. /* Packet-related variables */
  184.  
  185. int pktnum = 0,                         /* Current packet number */
  186.     sndtyp = 0,                /* Type of packet just sent */
  187.     rcvtyp = 0,                /* Type of packet just received */
  188.     rsn,                /* Received packet sequence number */
  189.     rln,                /* Received packet length */
  190.     size,                               /* Current size of output pkt data */
  191.     osize,                              /* Previous output packet data size */
  192.     maxsize,                            /* Max size for building data field */
  193.     spktl = 0,                /* Length packet being sent */
  194.     rpktl = 0,                /* Length of packet just received */
  195.     rprintf,                /* REMOTE PRINT flag */
  196.     rmailf;                /* MAIL flag */
  197.  
  198. CHAR
  199. #ifdef NO_MORE  /* Buffers used before sliding windows... */
  200.     sndpkt[MAXSP+100],            /* Entire packet being sent */
  201.     recpkt[MAXRP+200],            /* Packet most recently received */
  202.     data[MAXSP+4],            /* Packet data buffer */
  203. #endif
  204. #ifdef DYNAMIC
  205.     *srvcmd = (CHAR *)0,        /* Where to decode server command */
  206. #else
  207.     srvcmd[MAXRP+4],                    /* Where to decode server command */
  208. #endif
  209.     padbuf[95],                /* Buffer for send-padding */
  210.     *recpkt,
  211.     *rdatap,                /* Pointer to received packet data */
  212.     *data = (CHAR *)0,            /* Pointer to send-packet data */
  213.     *srvptr,                            /* Pointer to srvcmd */
  214.     mystch = SOH,                       /* Outbound packet-start character */
  215.     stchr = SOH;                        /* Incoming packet-start character */
  216.  
  217. /* File-related variables */
  218.  
  219. char filnam[257];                       /* Name of current file. */
  220. char cmdfil[80];            /* Application file name. */
  221.  
  222. int nfils = 0;                /* Number of files in file group */
  223. long fsize;                             /* Size of current file */
  224. int wildxpand = 0;            /* Who expands wildcards */
  225. int clfils = 0;                /* Flag for command-line files */
  226. int stayflg = 0;            /* Flag for "stay", i.e. "-S" */
  227.  
  228. /* Communication line variables */
  229.  
  230. char ttname[80];                        /* Name of communication line. */
  231.  
  232. #ifdef MAC
  233. int connected = 0;            /* true if connected */
  234. int startconnected;            /* initial state of connected */
  235. #endif /* MAC */
  236.  
  237. long speed = -1L;            /* Line speed */
  238.  
  239. int parity,                             /* Parity specified, 0,'e','o',etc */
  240.     autopar = 0,            /* Automatic parity change flag */
  241.     sosi = 0,                /* Shift-In/Out flag */
  242.     flow,                               /* Flow control */
  243.     turn = 0,                           /* Line turnaround handshake flag */
  244.     turnch = XON,                       /* Line turnaround character */
  245.     duplex = 0,                         /* Duplex, full by default */
  246.     escape = DFESC,            /* Escape character for connect */
  247.     delay = DDELAY,                     /* Initial delay before sending */
  248.     tnlm = 0,                /* Terminal newline mode */
  249.     mdmtyp = 0;                         /* Modem type (initially none)  */
  250.  
  251. int network = 0;
  252.  
  253. /* Other recent additions */
  254.  
  255.     int tlevel = -1;            /* Take-file command level */
  256. #ifndef NOSPL
  257.     extern int cmdlvl;            /* Command level */
  258.     extern int maclvl;            /* Macro invocation level */
  259. #endif /* NOSPL */
  260.     int carrier = CAR_AUT;        /* Pay attention to carrier signal */
  261.     int cdtimo = 0;            /* Carrier wait timeout */
  262.     int xitsta = GOOD_EXIT;        /* Program exit status */
  263.     int fncact = XYFX_X;        /* REPLACE for XPR Kermit */
  264.     int bgset = -1;            /* BACKGROUND mode set explicitly */
  265. #ifdef UNIX
  266.     int suspend = DFSUSP;        /* Whether SUSPEND command, etc, */
  267. #else                    /* is to be allowed. */
  268.     int suspend = 0;
  269. #endif /* UNIX */
  270.  
  271. /* Statistics variables */
  272.  
  273. long filcnt,                    /* Number of files in transaction */
  274.     flci,                       /* Characters from line, current file */
  275.     flco,                       /* Chars to line, current file  */
  276.     tlci,                       /* Chars from line in transaction */
  277.     tlco,                       /* Chars to line in transaction */
  278.     ffc,                        /* Chars to/from current file */
  279.     tfc,                        /* Chars to/from files in transaction */
  280.     rptn;            /* Repeated characters compressed */
  281.  
  282. int tsecs = 0;                  /* Seconds for transaction */
  283. int fsecs = 0;            /* Per-file timer */
  284.  
  285. /* Flags */
  286.  
  287. int deblog = 0,                         /* Flag for debug logging */
  288.     debses = 0,                /* Flag for DEBUG SESSION */
  289.     pktlog = 0,                         /* Flag for packet logging */
  290.     seslog = 0,                         /* Session logging */
  291.     tralog = 0,                         /* Transaction logging */
  292.     displa = 1,                         /* File transfer display on/off */
  293.     stdouf = 0,                         /* Flag for output to stdout */
  294.     stdinf = 0,                /* Flag for input from stdin */
  295.     xflg   = 0,                         /* Flag for X instead of F packet */
  296.     hcflg  = 0,                         /* Doing Host command */
  297.     fncnv  = 1,                         /* Flag for file name conversion */
  298.     binary = 0,                         /* Flag for binary file */
  299.     savmod = 0,                         /* Saved file mode (whole session) */
  300.     bsave  = 0,                /* Saved file mode (per file) */
  301.     bsavef = 0,                /* Flag if bsave was used. */
  302.     cmask  = 0177,            /* Connect byte mask */
  303.     fmask  = 0377,            /* File byte mask */
  304.     warn   = 0,                         /* Flag for file warning */
  305.     quiet  = 0,                         /* Be quiet during file transfer */
  306.     local  = 1,                         /* Flag for external tty vs stdout */
  307.     server = 0,                         /* Flag for being a server */
  308.     cflg   = 0,                /* Connect before transaction */
  309.     cnflg  = 0,                         /* Connect after transaction */
  310.     cxseen = 0,                         /* Flag for cancelling a file */
  311.     czseen = 0,                         /* Flag for cancelling file group */
  312.     discard = 0,            /* Flag for file to be discarded */
  313.     keep = 0,                           /* Keep incomplete files */
  314.     unkcs = 1,                /* Keep file w/unknown character set */
  315.     nakstate = 0,            /* In a state where we can send NAKs */
  316.     dblchar = -1;            /* Character to double when sending */
  317.  
  318. /* Variables passed from command parser to protocol module */
  319.  
  320. #ifndef NOSPL
  321. _PROTOTYP( int parser, (int) );         /* The parser itself */
  322. char *clcmds = NULL;            /* Pointer to command-line commands */
  323. #endif /* NOSPL */
  324.  
  325. CHAR sstate  = (CHAR) 0;                /* Starting state for automaton */
  326. CHAR zstate  = (CHAR) 0;        /* For remembering sstate */
  327. char *cmarg  = "";                      /* Pointer to command data */
  328. char *cmarg2 = "";                      /* Pointer to 2nd command data */
  329. char **cmlist;                          /* Pointer to file list in argv */
  330.  
  331. /* Flags for the ENABLE and DISABLE commands */
  332.  
  333. int en_cwd = 1;                /* CD/CWD */
  334. int en_del = 1;                /* DELETE */
  335. int en_dir = 1;                /* DIRECTORY */
  336. int en_fin = 1;                /* FINISH/BYE */
  337. int en_get = 1;                /* GET */
  338. #ifndef NOPUSH
  339. int en_hos = 1;                /* HOST enabled */
  340. #else
  341. int en_hos = 0;                /* HOST disabled */
  342. #endif /* NOPUSH */
  343. int en_sen = 1;                /* SEND */
  344. int en_set = 1;                /* SET */
  345. int en_spa = 1;                /* SPACE */
  346. int en_typ = 1;                /* TYPE */
  347. int en_who = 1;                /* WHO */
  348. #ifdef datageneral
  349. /* Data General AOS/VS can't do this */
  350. int en_bye = 0;                /* BYE */
  351. #else
  352. int en_bye = 1;                /* BYE */
  353. #endif /* datageneral */
  354.  
  355. /* Miscellaneous */
  356.  
  357. char **xargv;                           /* Global copies of argv */
  358. int  xargc;                             /* and argc  */
  359. int xargs;                /* an immutable copy of argc */
  360. char *xarg0;                /* and of argv[0] */
  361.  
  362. extern char *dftty;                     /* Default tty name from ck?tio.c */
  363. extern int dfloc;                       /* Default location: remote/local */
  364. extern int dfprty;                      /* Default parity */
  365. extern int dfflow;                      /* Default flow control */
  366.  
  367. /*
  368.   Buffered file input and output buffers.  See getpkt() in ckcfns.c
  369.   and zoutdump() in the system-dependent file i/o module (usually ck?fio.c).
  370. */
  371. #ifndef DYNAMIC
  372. /* Now we allocate them dynamically, see getiobs() below. */
  373. char zinbuffer[INBUFSIZE], zoutbuffer[OBUFSIZE];
  374. #endif
  375. char *zinptr, *zoutptr;
  376. int zincnt, zoutcnt;
  377.  
  378. _PROTOTYP( int getiobs, (void) );
  379.  
  380. /*
  381.  * xproto.h is the include file given in Appendix B.  It is included
  382.  * in ckxker.h
  383.  */
  384.  
  385. #include "ckxker.h"
  386.  
  387. long (*xupdate) (), (*xswrite) (), (*xfopen) (), (*xfclose) (), (*xfread) (),
  388.   (*xsread) (), (*xchkabort) (), (*xfnext) (), (*xffirst) (), (*xsflush) (),
  389.   (*xfwrite) (), (*xgets) (), (*xfinfo) (), (*xunlink)() ,
  390.   (*xsquery) (), (*xchkmisc) (), (*xsetserial)();
  391.  
  392. extern CHAR     start;        /* The start state for the protocol. */
  393.  
  394. /*
  395.  * Local prototypes.
  396.  */
  397. static KermitCd(struct XPR_IO *IO, char *dir);
  398. static KermitFinish(struct XPR_IO *IO);
  399. static KermitBye(struct XPR_IO *IO);
  400. static DoGeneric(struct XPR_IO *IO, char *s);
  401. static int setup(struct XPR_IO *IO);
  402.  
  403. extern int success;
  404.  
  405. /**
  406. *
  407. *   Send a (list of) files
  408. *
  409. **/
  410. long
  411. XProtocolSend(IO)
  412.     struct XPR_IO  *IO;
  413. {
  414.     struct XPR_UPDATE xpru;
  415.  
  416.     if (setup(IO) == 0)
  417.     return 0L;        /* Initialize parameters. */
  418.  
  419.     /*
  420.      * Set global text/binary flag based on return value from xpr_finfo,
  421.      * if present.  We could set this on a per-file basis.
  422.      */
  423.     if (xfinfo)
  424.         binary = (callad(xfinfo, IO->xpr_filename, 2L) == 1 ? 1 : 0);
  425.     /*
  426.      * Expand filenames.  This is not exactly how I'd intended this code
  427.      * to work.  CKCPLM.DOC implies that the system-independent code
  428.      * calls zxpand() if nfils is -1 to expand the file name list,
  429.      * followed by calling znext() to get the list one name at a time.
  430.      * This is not the case:  zxpand() is called by the system-dependent
  431.      * code in ckucmd.c.  Following its lead, we call zxpand() here but
  432.      * still set nfils to -1 in order to force gnfile() in the system
  433.      * independent code to call znext().
  434.      */
  435.     if (zxpand(IO->xpr_filename) < 0)
  436.         return 0L;
  437.     nfils = -1;
  438.     sstate = 's';
  439.     proto();
  440.  
  441.     if (!success)
  442.     return (0L);
  443.     else
  444.     return (1L);
  445. }
  446.  
  447. static int getfile = 0;        /* Flag as to whether to RECEIVE or GET */
  448.  
  449. /**
  450. *
  451. *   Receive a file.
  452. *
  453. **/
  454. long
  455. XProtocolReceive(IO)
  456.     struct XPR_IO  *IO;
  457. {
  458.     struct XPR_UPDATE xpru;
  459.     long            status;
  460.  
  461.     if (setup(IO) == 0)
  462.     return 0L;            /* Initialize parameters. */
  463.  
  464.     /*
  465.      * Read the text/binary set using xpr_finfo if present.  Else use the
  466.      * value chosen in XPRotocolSetup.
  467.      */
  468.     if (xfinfo) {
  469.     /*
  470.      * Use feature th at calling xpr_finfo with a zero-length filename
  471.      * returns setting of internal comm program Text/Binary flag.
  472.      */
  473.     binary = (callad(xfinfo, "", 2L) == 1 ? 1 : 0);
  474.     }
  475.  
  476.     if (getfile) {
  477.     /*
  478.      * Get filename, and put pointer in external Kermit variable.
  479.      */
  480.     cmarg2 = NULL;
  481.     nfils = -1;
  482.     sstate = 'r';
  483. #ifdef COMMENT
  484.     if (IO->xpr_filename != NULL && IO->xpr_filename[0] != '\0')
  485.         cmarg = IO->xpr_filename;
  486.     else { 
  487.         status = callaa(xgets, "Host Filename", cmarg);
  488.         if (!status)
  489.             return (0L);
  490.     }
  491. #else
  492.     status = callaa(xgets, "Host Filename", cmarg);
  493.     if (!status)
  494.         return (0L);
  495. #endif
  496.     } else {
  497.     sstate = 'v';
  498.     cmarg = cmarg2 = NULL;
  499.     }
  500.     proto();
  501.  
  502.     if (!success)
  503.     return (0L);
  504.     else
  505.     return (1L);
  506. }
  507.  
  508. /*
  509.  * Perform a generic Kermit server command.
  510.  */
  511. static
  512. DoGeneric(IO, s)
  513.     struct XPR_IO  *IO;
  514.     char           *s;
  515. {
  516.     if (setup(IO) == 0)
  517.     return 0;            /* Set up transfer characteristics. */
  518.     sstate = 'g';
  519.     cmarg = s;
  520.     proto();
  521.     if (!success)
  522.     return (0);
  523.     else
  524.     return (1);
  525. }
  526.  
  527. /*
  528.  * Execute a Kermit FINISH command.
  529.  */
  530. static
  531. KermitFinish(IO)
  532.     struct XPR_IO  *IO;
  533. {
  534.     return (DoGeneric(IO, "F"));
  535. }
  536.  
  537. /*
  538.  * Execute a Kermit BYE command.
  539.  */
  540. static
  541. KermitBye(IO)
  542.     struct XPR_IO  *IO;
  543. {
  544.     return (DoGeneric(IO, "L"));
  545. }
  546.  
  547. /*
  548.  * Change directory on remote server.  We need to return an error if the CD
  549.  * fails on the remote end.
  550.  */
  551. static
  552. KermitCd(IO, dir)
  553.     struct XPR_IO  *IO;
  554.     char           *dir;
  555. {
  556.     char            CdCommand[100];
  557.     int             retval;
  558.  
  559.     CdCommand[0] = 'C';
  560.     CdCommand[1] = (char) tochar(strlen(dir));
  561.     strcpy(CdCommand + 2, dir);
  562.     retval = DoGeneric(IO, CdCommand);
  563.     return retval;
  564. }
  565.  
  566. /**
  567. *
  568. *   Setup
  569. *
  570. * First, a general-purpose comparison for either of the two possible returns
  571. * indicating a Yes push on a Boolean gadget.
  572. **/
  573.  
  574. #define XprBoolTrue(s) ((stricmp(s, "yes") == 0) || (stricmp(s, "on") == 0))
  575.  
  576. /*
  577.  * Then, a small set of code to initialize a string based on a value.
  578.  */
  579.  
  580. #define XprSet(value, string) ((value) ? \
  581.    (void) strcpy(string, YesString) : \
  582.    (void) strcpy(string, NoString)) \
  583.  
  584. static char     YesString[] = "yes";
  585. static char     NoString[] = "no";
  586.  
  587. /*
  588.  * If Setup() succeeds, flag same.  Also, we don't need a file requester
  589.  * on receive.
  590.  */
  591. #define SUCCESS (XPRS_SUCCESS | XPRS_NORECREQ)
  592.  
  593. extern char _H1_org, _H1_end, _H2_org, _H2_end;        /* Data segment pointers */
  594. static void NewDataSeg(void *);
  595.  
  596. #pragma regcall(NewDataSeg(a0))
  597.  
  598. #include <exec/memory.h>
  599. #include <clib/exec_protos.h>
  600. #include <pragmas/exec_pragmas.h>
  601.  
  602. /*
  603.  * IMPLEMENTATION NOTE
  604.  *
  605.  * InitData() and NewDataSeg() implement the Manx-dependent code to
  606.  * make XPR Kermit re-entrant.  I take advantage of the fact that the
  607.  * XPR library has only four entry points, and call the setup() routine
  608.  * from each one.  setup() in turn calls InitData(), whose job it is
  609.  * to allocate a new data segment if IO->xpr_data is NULL, and then to
  610.  * put that data segment address into register a4.  This works for two
  611.  * reasons:  first, because the code is re-entrant up to the time the
  612.  * call to NewDataSeg() occurs, and second, because the call to geta4())
  613.  * which the Manx compiler inserts into the external entry points happens
  614.  * before the call to setup() at the beginning of each routine above.
  615.  *
  616.  * The arguably best solution is to have a technique for returning a
  617.  * different Library base pointer to each opener and initialize the
  618.  * data segment then.  The SAS/C compiler makes this possible.
  619.  */
  620. int
  621. InitData(struct XPR_IO *IO) {
  622.  
  623.     /*
  624.      * Allocate memory for file name buffer and options if first call.  Also
  625.      * allocate user's data segment and point us at it.
  626.      */
  627.     if (IO->xpr_data == NULL) {
  628.     if ((IO->xpr_data = AllocMem(&_H2_end - &_H1_org + 4, 0L)) == NULL) {
  629.         return 0;
  630.     }
  631.     CopyMem(&_H1_org, IO->xpr_data, &_H2_end - &_H1_org + 4);
  632.     }
  633.     NewDataSeg(IO->xpr_data);
  634.     return(1);
  635. }
  636.  
  637. long
  638. XProtocolSetup(IO)
  639.     struct XPR_IO  *IO;
  640. {
  641.     long            (*xoptions) ();
  642. #define NOPTS 15
  643.    /*
  644.     * The "static" here is to prevent these from being allocated off
  645.     * the stack---we want to minimize stack usage in a library.
  646.     */
  647.     static struct xpr_option opt[NOPTS], *popt[NOPTS];
  648. #define MAXSTRING 6
  649.     char            ValueStrings[NOPTS][MAXSTRING];
  650.     long            status;
  651.     int             i, j;
  652.     char            buf[256];
  653.  
  654.     if (InitData(IO) == 0)
  655.         return (XPRS_FAILURE);
  656.  
  657.     if ((xupdate = IO->xpr_update) == NULL)
  658.     return (XPRS_FAILURE);
  659.     if ((xgets = IO->xpr_gets) == NULL)
  660.     return (XPRS_FAILURE);
  661.  
  662.     /*
  663.      * In order to use xpr_options, we must have all of the three conditions
  664.      * which follow true.  Otherwise, either IO->xpr_filename is non-NULL, in
  665.      * which case we assume it contains a setup string, or there is no
  666.      * xpr_options, in which case we use xpr_gets to retrieve a setup string.
  667.      */
  668.     if (IO->xpr_filename == NULL &&
  669.     IO->xpr_extension >= 1 &&
  670.     (xoptions = IO->xpr_options) != NULL) {
  671.  
  672.     /*
  673.      * I use a counter, i, here, so that I can stick in more options
  674.      * without needing to change a lot of numbers.  I can also skip
  675.      * options dynamically, as in Text below.
  676.      */
  677.     i = 0;
  678.     /* Announce us. */
  679.     opt[i].xpro_description = versio;
  680.     opt[i].xpro_type = XPRO_HEADER;
  681.     opt[i].xpro_value = NULL;
  682.     opt[i].xpro_length = 0;
  683.     i++;
  684.     /*
  685.      * First, do the Kermit server command items.
  686.      */
  687.     opt[i].xpro_description = "Kermit FINISH";
  688.     opt[i].xpro_type = XPRO_COMMAND;
  689.     opt[i].xpro_value = NULL;
  690.     opt[i].xpro_length = 0;
  691.     i++;
  692.     opt[i].xpro_description = "Kermit BYE";
  693.     opt[i].xpro_type = XPRO_COMMAND;
  694.     opt[i].xpro_value = NULL;
  695.     opt[i].xpro_length = 0;
  696.     i++;
  697.     opt[i].xpro_description = "Kermit CD";
  698.     opt[i].xpro_type = XPRO_COMMPAR;
  699.     buf[0] = '\0';
  700.     opt[i].xpro_value = buf;        /* Use buf to hold dir name. */
  701.     opt[i].xpro_length = sizeof(buf) - 1;
  702.     i++;
  703.     opt[i].xpro_description = "Kermit Options";
  704.     opt[i].xpro_type = XPRO_COMMAND;
  705.     opt[i].xpro_value = NULL;
  706.     opt[i].xpro_length = 0;
  707.     i++;
  708.     /* show requester after loading pointers */
  709.     for (j = 0; j < i; j++)
  710.         popt[j] = &opt[j];
  711.     status = callda(xoptions, (long) i, popt);
  712.     /* check returned value */
  713.     if (status == -1L)
  714.         return XPRS_FAILURE;
  715.     /* Check returned value to see what we are to do. */
  716.     i = 1;
  717.     if (status & (1L << i))
  718.         return (KermitFinish(IO) ? SUCCESS : XPRS_FAILURE);
  719.     i++;
  720.     if (status & (1L << i))
  721.         return (KermitBye(IO) ? SUCCESS : XPRS_FAILURE);
  722.     i++;
  723.     if (status & (1L << i))
  724.         return (KermitCd(IO, opt[i].xpro_value) ? SUCCESS : XPRS_FAILURE);
  725.     /* If we get to this point, we are to set options. */
  726.     i = 0;            /* Start over. */
  727.     opt[i].xpro_description = versio;
  728.     opt[i].xpro_type = XPRO_HEADER;
  729.     opt[i].xpro_value = NULL;
  730.     opt[i].xpro_length = 0;
  731.     i++;
  732.     /* Convert filename */
  733.     opt[i].xpro_description = "Convert Filename";
  734.     opt[i].xpro_type = XPRO_BOOLEAN;
  735.     XprSet(fncnv, ValueStrings[i]);
  736.     opt[i].xpro_value = ValueStrings[i];
  737.     opt[i].xpro_length = MAXSTRING;
  738.     i++;
  739.     /* Partial file keep */
  740.     opt[i].xpro_description = "Keep Incomplete";
  741.     opt[i].xpro_type = XPRO_BOOLEAN;
  742.     XprSet(keep, ValueStrings[i]);
  743.     opt[i].xpro_value = ValueStrings[i];
  744.     opt[i].xpro_length = MAXSTRING;
  745.     i++;
  746.     /* host is server */
  747.     opt[i].xpro_description = "Host Server";
  748.     opt[i].xpro_type = XPRO_BOOLEAN;
  749.     XprSet(getfile, ValueStrings[i]);
  750.     opt[i].xpro_value = ValueStrings[i];
  751.     opt[i].xpro_length = MAXSTRING;
  752.     i++;
  753.     /* File name collision option */
  754.     opt[i].xpro_description = "Collision Action";
  755.     opt[i].xpro_type = XPRO_STRING;
  756.     switch (fncact) {
  757.         case XYFX_A:
  758.             strcpy(ValueStrings[i], "A");
  759.             break;
  760.         case XYFX_D:
  761.             strcpy(ValueStrings[i], "D");
  762.             break;
  763.         case XYFX_R:
  764.             strcpy(ValueStrings[i], "R");
  765.             break;
  766.         case XYFX_X:
  767.             strcpy(ValueStrings[i], "X");
  768.             break;
  769.         default:
  770.             strcpy(ValueStrings[i], "?");
  771.             break;
  772.     }
  773.     opt[i].xpro_value = ValueStrings[i];
  774.     opt[i].xpro_length = 1;
  775.     i++;
  776.     /*
  777.      * file type -- only show this if xpr_finfo not present, or returns
  778.      * error when we try to get the file type.
  779.      */
  780.     if ((xfinfo = IO->xpr_finfo) == NULL ||
  781.         (binary = (int) (callad(xfinfo, "", 2L))) == 0) {
  782.         binary = -1;        /* Flag xfinfo failed. */
  783.         opt[i].xpro_description = "Text File";
  784.         opt[i].xpro_type = XPRO_BOOLEAN;
  785.         XprSet(binary ? 0 : 1, ValueStrings[i]);
  786.         opt[i].xpro_value = ValueStrings[i];
  787.         opt[i].xpro_length = MAXSTRING;
  788.         i++;
  789.     } else
  790.         /*
  791.          * Switch to 1 for binary, 0 for text; xpr_finfo returns 1 for
  792.          * binary, 2 for text.
  793.          */
  794.         binary = (binary == 1 ? 1 : 0);
  795.     /* Packet size */
  796.     opt[i].xpro_description = "Packet Size";
  797.     opt[i].xpro_type = XPRO_LONG;
  798.     (void) sprintf(ValueStrings[i], "%-d", urpsiz);
  799.     opt[i].xpro_value = ValueStrings[i];
  800.     opt[i].xpro_length = MAXSTRING;
  801.     i++;
  802.     /* Block Check type */
  803.     opt[i].xpro_description = "Block Check (1, 2, 3)";
  804.     opt[i].xpro_type = XPRO_LONG;
  805.     (void) sprintf(ValueStrings[i], "%-d", bctr);
  806.     opt[i].xpro_value = ValueStrings[i];
  807.     opt[i].xpro_length = MAXSTRING;
  808.     i++;
  809.     /* Retry Limit */
  810.     opt[i].xpro_description = "Maximum Retries";
  811.     opt[i].xpro_type = XPRO_LONG;
  812.     (void) sprintf(ValueStrings[i], "%-d", maxtry);
  813.     opt[i].xpro_value = ValueStrings[i];
  814.     opt[i].xpro_length = MAXSTRING;
  815.     i++;
  816.     /* Timeout */
  817.     opt[i].xpro_description = "Timeout (seconds)";
  818.     opt[i].xpro_type = XPRO_LONG;
  819.     (void) sprintf(ValueStrings[i], "%-d", rtimo);
  820.     opt[i].xpro_value = ValueStrings[i];
  821.     opt[i].xpro_length = MAXSTRING;
  822.     i++;
  823.     /* Number of windows */
  824.     opt[i].xpro_description = "Window Slots";
  825.     opt[i].xpro_type = XPRO_LONG;
  826.     (void) sprintf(ValueStrings[i], "%-d", wslotr);
  827.     opt[i].xpro_value = ValueStrings[i];
  828.     opt[i].xpro_length = MAXSTRING;
  829.     i++;
  830.     /* Send packet size */
  831.     opt[i].xpro_description = "Send Packet Size";
  832.     opt[i].xpro_type = XPRO_LONG;
  833.     (void) sprintf(ValueStrings[i], "%-d", (spsizf == 0 ? 0 : spsiz));
  834.     opt[i].xpro_value = ValueStrings[i];
  835.     opt[i].xpro_length = MAXSTRING;
  836.     i++;
  837.     /* Send timeout */
  838.     opt[i].xpro_description = "Send Timeout";
  839.     opt[i].xpro_type = XPRO_LONG;
  840.     (void) sprintf(ValueStrings[i], "%-d", (timef == 0 ? 0 : timint));
  841.     opt[i].xpro_value = ValueStrings[i];
  842.     opt[i].xpro_length = MAXSTRING;
  843.     i++;
  844.     /* show requester after loading pointers */
  845.     for (j = 0; j < i; j++)
  846.         popt[j] = &opt[j];
  847.     /* show requester */
  848.     status = callda(xoptions, (long) i, popt);
  849.     /* check returned value */
  850.     if (status == -1L)
  851.         return XPRS_FAILURE;
  852.     i = 1;            /* Skip header         */
  853.     if (status & (1L << i))
  854.         fncnv = XprBoolTrue(opt[i].xpro_value) ? 1 : 0;
  855.     i++;
  856.     if (status & (1L << i))
  857.         keep = XprBoolTrue(opt[i].xpro_value) ? 1 : 0;
  858.     i++;
  859.     if (status & (1L << i))
  860.         getfile = XprBoolTrue(opt[i].xpro_value) ? 1 : 0;
  861.     i++;
  862.     if (status & (1L << i)) {
  863.        switch(ValueStrings[i][0]) {
  864.            case 'A':
  865.                fncact = XYFX_A;
  866.                break;
  867.            case 'D':
  868.                fncact = XYFX_D;
  869.                break;
  870.            case 'R':
  871.                fncact = XYFX_R;
  872.                break;
  873.            case 'X':
  874.                fncact = XYFX_X;
  875.                break;
  876.            default:
  877.                fncact = XYFX_X;        /* Default is replace */
  878.                break;
  879.        }
  880.     }
  881.     i++;
  882.     if (xfinfo == NULL || binary == -1) {
  883.         if (status & (1L << i))
  884.         binary = XprBoolTrue(opt[i].xpro_value) ? 0 : 1;
  885.         i++;
  886.     }
  887.     if (status & (1L << i))
  888.         urpsiz = atoi(opt[i].xpro_value);
  889.     i++;
  890.     if (status & (1L << i))
  891.         bctr = atoi(opt[i].xpro_value);
  892.     i++;
  893.     if (status & (1L << i))
  894.         maxtry = atoi(opt[i].xpro_value);
  895.     i++;
  896.     if (status & (1L << i)) {
  897.         rtimo = atoi(opt[i].xpro_value);
  898.         if (rtimo < 5) rtimo = 5;
  899.     }
  900.         i++;
  901.     if (status & (1L << i))
  902.         wslotr = atoi(opt[i].xpro_value);
  903.     i++;
  904.     if (status & (1L << i)) {
  905.         spsiz = atoi(opt[i].xpro_value);
  906.         spsizf = (spsiz > 0 ? 1 : 0);
  907.     }
  908.     i++;
  909.     if (status & (1L << i)) {
  910.         timint = atoi(opt[i].xpro_value);
  911.         timef = (timint > 0 ? 1: 0);
  912.     }
  913.     i++;
  914.     } else {
  915.     if (IO->xpr_filename != NULL)
  916.         strcpy(buf, IO->xpr_filename);    /* Save setup string */
  917.     else {            /* Prompt for command/options string */
  918.         char collision;
  919.  
  920.         switch (fncact) {
  921.             case XYFX_A:
  922.                 collision = 'A';
  923.                 break;
  924.             case XYFX_D:
  925.                 collision =  'D';
  926.             break;
  927.             case XYFX_R:
  928.                 collision = 'R';
  929.                 break;
  930.             case XYFX_X:
  931.                 collision = 'X';
  932.                 break;
  933.             default:
  934.                 collision = '?';
  935.                 break;
  936.             }
  937.         sprintf(buf, "OC%c,G%c,K%c,T%c,N%c,P%d,B%d,R%d,O%d,W%d,SP%d,SO%d",
  938.                     fncnv ? 'Y' : 'N',
  939.             getfile ? 'Y' : 'N', keep ? 'Y' : 'N',
  940.                     binary ? 'N' : 'Y',
  941.                     collision,
  942.                     urpsiz, bctr, maxtry, rtimo, wslotr,
  943.                     (spsizf <= 0 ? 0 : spsiz),
  944.                     (timef <= 0 ? 0 : timint));
  945.         if (callaa(xgets, "Kermit Options", buf) == 0)
  946.         return XPRS_FAILURE;    /* Failed to set up? */
  947.     }
  948.     (void) strupr(buf);
  949.     switch (buf[0]) {
  950.     case 'F':
  951.         return (KermitFinish(IO) ? SUCCESS : XPRS_FAILURE);
  952.     case 'B':
  953.         return (KermitBye(IO) ? SUCCESS : XPRS_FAILURE);
  954.     case 'C':
  955.         return (KermitCd(IO, buf + 1) ? SUCCESS : XPRS_FAILURE);
  956.     case 'O':
  957.         if (SetupFromString(IO, buf) == 0)
  958.         return XPRS_FAILURE;
  959.         break;
  960.     case '\0':
  961.         break;
  962.     default:
  963.         ioerr(IO, "Unrecognized XPR Kermit setup string");
  964.         break;
  965.     }
  966.     }
  967.     /*
  968.      * Return success and inform caller that we don't need a requester for
  969.      * receive.
  970.      */
  971.     return SUCCESS;
  972. }
  973.  
  974. static char Delimiters[] = " \t\r\n,";
  975.  
  976. int
  977. SetupFromString(IO, s)
  978.     struct XPR_IO  *IO;
  979.     char           *s;
  980. {
  981.     char           *p;
  982.     char            errbuf[50];
  983.  
  984.     if (*s != 'O')
  985.     return 0;        /* Options string must start with O. */
  986.     s++;            /* Skip leading O. */
  987.     /*
  988.      * Hunt for options with strtok.  We allow whitespace and commas to
  989.      * separate options.
  990.      */
  991.     for (p = strtok(s, Delimiters); p != NULL; p = strtok(NULL, Delimiters)) {
  992.     switch (*p++) {                /* Auto-increment to option */
  993.     case 'C':                /* Case conversion. */
  994.         if (*p == 'Y' || *p == 'N')
  995.         fncnv = (*p == 'Y');
  996.         else
  997.         ioerr(IO, "Illegal C option format (must be Y or N)");
  998.         break;
  999.     case 'G':                /* Get files (Host server) */
  1000.         if (*p == 'Y' || *p == 'N')
  1001.         getfile = (*p == 'Y');
  1002.         else
  1003.         ioerr(IO, "Illegal G option format (must be Y or N)");
  1004.         break;
  1005.     case 'K':                /* Keep incomplete file */
  1006.         if (*p == 'Y' || *p == 'N')
  1007.         keep = (*p == 'Y');
  1008.         else
  1009.         ioerr(IO, "Illegal K option format (must be Y or N)");
  1010.         break;
  1011.     case 'T':                /* Text file */
  1012.         if (*p == 'Y' || *p == 'N')
  1013.         binary = (*p == 'N');
  1014.         else
  1015.         ioerr(IO, "Illegal T option format (must be Y or N)");
  1016.         break;
  1017.     case 'N':                /* File name collision */
  1018.             switch(*p) {
  1019.            case 'A':
  1020.                fncact = XYFX_A;
  1021.                break;
  1022.            case 'D':
  1023.                fncact = XYFX_D;
  1024.                break;
  1025.            case 'R':
  1026.                fncact = XYFX_R;
  1027.                break;
  1028.            case 'X':
  1029.                fncact = XYFX_X;
  1030.                break;
  1031.            default:
  1032.                fncact = XYFX_X;        /* Default is replace */
  1033.                break;
  1034.         }
  1035.         break;
  1036.     case 'P':                /* Maximum packet length */
  1037.         urpsiz = atoi(p);
  1038.         break;
  1039.     case 'B':                /* Block check type. */
  1040.         bctr = atoi(p);
  1041.         if (bctr < 1 || bctr > 3) {
  1042.            ioerr(IO, "Block check type must be between 1 and 3");
  1043.            bctr = 1;
  1044.         }
  1045.         break;
  1046.     case 'R':                /* Retry limit */
  1047.         maxtry = atoi(p);
  1048.         break;
  1049.     case 'O':                /* Timeout */
  1050.         rtimo = atoi(p);
  1051.         if (rtimo < 5) {
  1052.            ioerr(IO, "Timeout too short---using 5 second minimum");
  1053.            rtimo = 5;
  1054.         }
  1055.         break;
  1056.     case 'W':                /* Window Slots */
  1057.         wslotr = atoi(p);
  1058.         if (wslotr < 1) wslotr = 1;
  1059.         break;
  1060.     case 'S':                /* Default send overrides */
  1061.         switch (*p) {
  1062.             case 'P':            /* Send packet size */
  1063.                 spsiz = atoi(p+1);
  1064.                 if (spsiz > 0) spsizf = 1;
  1065.                 break;
  1066.             case 'O':            /* Send timeout */
  1067.                 timint = atoi(p+1);
  1068.                 if (timint > 0) {
  1069.             timef = 1;
  1070.             if (timint < 5) timint = 5;
  1071.             }
  1072.                 break;
  1073.             default:
  1074.                 sprintf(errbuf, "Illegal XPR Kermit option: %s", p-1);
  1075.                 ioerr(IO, errbuf);
  1076.                 break;
  1077.         }
  1078.         break;
  1079.     default:
  1080.         sprintf(errbuf, "Illegal XPR Kermit option: %s", p-1);
  1081.         ioerr(IO, errbuf);
  1082.         break;
  1083.     }
  1084.     }
  1085.     return 1;
  1086. }
  1087.  
  1088. /**
  1089. *
  1090. *   Cleanup.  Because of the way we do re-entrancy, we can use the
  1091. *   Aztec malloc()/free(), which sets up the _cln pointer as shown
  1092. *   to clean up all allocated memory.  Following this, we deallocate
  1093. *   the data segment in a re-entrant way as well.
  1094. *
  1095. **/
  1096.  
  1097. void (*_cln)(void);
  1098.  
  1099. long
  1100. XProtocolCleanup(IO)
  1101.     struct XPR_IO  *IO;
  1102. {
  1103.     if (IO->xpr_data != NULL) {
  1104.         NewDataSeg(IO->xpr_data);
  1105.         if (_cln)
  1106.             (*_cln)();
  1107.         FreeMem(IO->xpr_data, &_H2_end - &_H1_org + 4);
  1108.         IO->xpr_data = NULL;
  1109.     }
  1110.  
  1111.     return (1L);
  1112. }
  1113.  
  1114. int
  1115. XPRParity(IO)
  1116.     struct XPR_IO  *IO;
  1117. {
  1118.     long            status;
  1119.  
  1120.     /* check out parity */
  1121.     if ((xsetserial = IO->xpr_setserial) != NULL) {
  1122.     status = calld(xsetserial, -1L);
  1123.     if (status & 0x00000001L)
  1124.         return 1;
  1125.     else
  1126.         return 0;
  1127.     } else
  1128.     return 0;        /* Assume no parity if can't tell. */
  1129. }
  1130.  
  1131. void
  1132. XPRLong(IO, i)
  1133.     struct XPR_IO  *IO;
  1134.     long            i;
  1135. {
  1136.     struct XPR_UPDATE xpru;
  1137.     char            locbuf[80];
  1138.  
  1139.     if ((xupdate = IO->xpr_update) == NULL)
  1140.     return;
  1141.     /* debug: show long value */
  1142.     xpru.xpru_updatemask = XPRU_MSG;
  1143.     sprintf(locbuf, "%lx", i);
  1144.     xpru.xpru_msg = &locbuf[0];
  1145.     (void) calla(xupdate, &xpru);
  1146. }
  1147.  
  1148. /*
  1149.  * Get all the callback routines we need.  We do this because there is a
  1150.  * small chance that the callbacks could change dynamically.
  1151.  */
  1152. int
  1153. setup(IO)
  1154.     struct XPR_IO  *IO;
  1155. {
  1156.  
  1157.     if (InitData(IO) == 0)
  1158.         return 0;
  1159.     /*
  1160.      * These are the call-backs we need. If any of them isn't provided, quit.
  1161.      * Could do some error reporting if at least xupdate is there.
  1162.      */
  1163.     if ((xupdate = IO->xpr_update) == NULL)
  1164.     return 0;
  1165.     if ((xswrite = IO->xpr_swrite) == NULL)
  1166.     return 0;
  1167.     if ((xfopen = IO->xpr_fopen) == NULL)
  1168.     return 0;
  1169.     if ((xfclose = IO->xpr_fclose) == NULL)
  1170.     return 0;
  1171.     if ((xfread = IO->xpr_fread) == NULL)
  1172.     return 0;
  1173.     if ((xsread = IO->xpr_sread) == NULL)
  1174.     return 0;
  1175.     if ((xchkabort = IO->xpr_chkabort) == NULL)
  1176.     return 0;
  1177.     if ((xfnext = IO->xpr_fnext) == NULL)
  1178.     return 0;
  1179.     if ((xffirst = IO->xpr_ffirst) == NULL)
  1180.     return 0;
  1181.     if ((xsflush = IO->xpr_sflush) == NULL)
  1182.     return 0;
  1183.     if ((xfwrite = IO->xpr_fwrite) == NULL)
  1184.     return 0;
  1185.     if ((xgets = IO->xpr_gets) == NULL)
  1186.     return 0;
  1187.     if ((xsetserial = IO->xpr_setserial) == NULL)
  1188.         return 0;
  1189.     /*
  1190.      * Here are callbacks we can do without.
  1191.      */
  1192.     xchkmisc = IO->xpr_chkmisc;
  1193.     if (IO->xpr_extension >= 2)
  1194.     xunlink = IO->xpr_unlink;
  1195.     else
  1196.     xunlink = NULL;
  1197.     if (IO->xpr_extension >= 3)
  1198.         xsquery = IO->xpr_squery;
  1199.     else
  1200.     xsquery = NULL;
  1201.     xfinfo = IO->xpr_finfo;
  1202.  
  1203.     /*
  1204.      * Some Kermit setup stuff.  Allocate buffers for send and receive.
  1205.      */
  1206.     if (getiobs() < 0)
  1207.         return 0;
  1208.     if (inibufs(SBSIZ,RBSIZ) < 0)
  1209.         return 0;
  1210.     /*
  1211.      * Set the speed and that we are in local mode.
  1212.      */
  1213.     local = 1;
  1214.     speed = ttgspd();
  1215.     return 1;
  1216. }
  1217.  
  1218. /*
  1219.  * Set the current context's data segment (small model) to the value
  1220.  * in DataSeg.  Uses (undocumented) feature of compiler which allows
  1221.  * access to variables by name between #asm ... #endasm if preceded
  1222.  * by double percent sign.
  1223.  */
  1224. /*lint -esym(528,NewDataSeg) */
  1225.  
  1226. void
  1227. NewDataSeg(void *DataSeg) {
  1228. #ifndef _lint
  1229.  
  1230.     ;
  1231. #asm
  1232.     movea.l    %%DataSeg,a4
  1233.     add.l    #32766,a4
  1234. #endasm
  1235.  
  1236. #endif
  1237. }
  1238.  
  1239. /*
  1240.  * Have the comm program display an error message for us, using a temporary
  1241.  * XPR_UPDATE structure; used to display errors before Vars gets allocated
  1242.  */
  1243. void
  1244. ioerr(IO, msg)
  1245.     struct XPR_IO  *IO;
  1246.     char           *msg;
  1247. {
  1248.     struct XPR_UPDATE xpru;
  1249.  
  1250.     if ((xupdate = IO->xpr_update) != NULL) {
  1251.     xpru.xpru_updatemask = XPRU_ERRORMSG;
  1252.     xpru.xpru_errormsg = msg;
  1253.     (void) calla(xupdate, &xpru);
  1254.     }
  1255. }
  1256.  
  1257. /**
  1258. *
  1259. *   The following functions setup the proper registers for the call-back
  1260. *   functions.
  1261. *
  1262. **/
  1263.  
  1264. #ifndef _lint
  1265.  
  1266. #asm
  1267.         public _callad
  1268. _callad:
  1269.         movea.l 8(sp),a0                ; Second argument goes in a0
  1270.         move.l  12(sp),d0               ; Third  argument goes in d0
  1271. /*
  1272. *   Now this is a trick to avoid using another register.
  1273. *   Charlie taught me this...
  1274. */
  1275.         move.l  4(sp),-(sp)             ; First  argument is function
  1276.         rts
  1277.  
  1278.         public  _calladda
  1279. _calladda:
  1280.         movea.l 8(sp),a0                ; Second argument goes in a0
  1281.         move.l  12(sp),d0               ; Third  argument goes in d0
  1282.         move.l  16(sp),d1               ; Fourth argument goes in d1
  1283.         movea.l 20(sp),a1               ; Fifth  argument goes in a1
  1284.         move.l  4(sp),-(sp)             ; First  argument is function
  1285.         rts
  1286.  
  1287.         public  _calldaa
  1288. _calldaa:
  1289.         move.l  8(sp),d0                ; Second  argument goes in d0
  1290.         movea.l 12(sp),a0               ; Third argument goes in a0
  1291.         movea.l 16(sp),a1               ; Fourth argument goes in a1
  1292.         move.l  4(sp),-(sp)             ; First  argument is function
  1293.         rts
  1294.  
  1295.         public  _calla
  1296. _calla:
  1297.         movea.l 8(sp),a0                ; Second argument goes in a0
  1298.         move.l  4(sp),-(sp)             ; First  argument is function
  1299.         rts
  1300.  
  1301.         public  _calld
  1302. _calld:
  1303.         move.l  8(sp),d0                ; Second argument goes in d0
  1304.         move.l  4(sp),-(sp)             ; First  argument is function
  1305.         rts
  1306.  
  1307.         public  _callaa
  1308. _callaa:
  1309.         movea.l 8(sp),a0                ; Second argument goes in a0
  1310.         movea.l 12(sp),a1               ; Third  argument goes in a1
  1311.         move.l  4(sp),-(sp)             ; First  argument is function
  1312.         rts
  1313.  
  1314.         public  _callda
  1315. _callda:
  1316.         move.l  8(sp),d0                ; Second argument goes in d0
  1317.         movea.l 12(sp),a0               ; Third  argument goes in a0
  1318.         move.l  4(sp),-(sp)             ; First  argument is function
  1319.         rts
  1320.  
  1321.         public  _calladd
  1322. _calladd:
  1323.         movea.l  8(sp),a0               ; Second argument goes in a0
  1324.         move.l  12(sp),d0               ; Third  argument goes in d0
  1325.         move.l  16(sp),d1               ; Fourth argument goes in d1
  1326.         move.l  4(sp),-(sp)             ; First  argument is function
  1327.         rts
  1328.  
  1329. #endasm
  1330. /*
  1331. *   Could have added any other functions needed for other call-backs.
  1332. *   Could have written a fancier single one... Could've...
  1333. */
  1334. #endif
  1335.  
  1336. #ifdef DYNAMIC
  1337. /* Allocate file i/o buffers */
  1338.  
  1339. char *zinbuffer, *zoutbuffer;
  1340.  
  1341. int
  1342. getiobs() {
  1343.     if (!zinbuffer)
  1344.         zinbuffer = (char *)malloc(INBUFSIZE);
  1345.     if (!zinbuffer) return(-1);
  1346.     if (!zoutbuffer)
  1347.         zoutbuffer = (char *)malloc(OBUFSIZE);
  1348.     if (!zoutbuffer) return(-1);    
  1349.     debug(F100,"getiobs ok","",0);
  1350.     return(0);
  1351. }
  1352.  
  1353. #endif /* DYNAMIC */
  1354.